home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / general / viewers / polyview / polyvw20.lha / PolyView2.0 / Examples / m.c < prev    next >
C/C++ Source or Header  |  1991-07-26  |  8KB  |  399 lines

  1. /*
  2. MD.C
  3. NCSA Software Tools Group
  4. November 29, 1989
  5.  
  6. DESCRIPTION
  7. This program creates a sample HDF per-vertex data file useful for testing
  8. PolyView.  The file describes a number of simple three-dimensional objects and
  9. associated scientific data.
  10.  
  11. The created file is named "demo.hdf" and contains the following vgroups and
  12. vdataatasets:
  13.  
  14.     group1    Vgroup containing all of the following data
  15.  
  16.     px    X dimension data set
  17.     py    Y dimension data set
  18.     pz    Z dimension data set
  19.  
  20.     plist3    connectivity list for triangles only
  21.     plist4    connectivity list for triangles and quadrilaterals
  22.  
  23.     random    random scientific data
  24. */
  25.  
  26. /* INCLUDES */
  27. #include <stdio.h>
  28. #include <ctype.h>
  29. #include "df.h"
  30. #include "dfi.h"
  31. #include "vg.h"
  32.  
  33.  
  34. /* DEFINES */
  35. #define POINTS    5000
  36. #define VERTS    5000
  37.  
  38. /* Random number generator information */
  39. #define MAX_RND         (1<<31)
  40. #define RND(min,max)    (double)(((((double)lcm_rnd())/(MAX_RND-1))*\
  41.                             ((double) max - (double) min)) + (double) min)
  42.  
  43.  
  44. /* TYPES */
  45.  
  46.  
  47. /* GLOBAL VARIABLES */
  48. float    px[VERTS];
  49. float    py[VERTS];
  50. float    pz[VERTS];
  51.  
  52. int    plist3[VERTS];
  53. int    plist4[VERTS];
  54.  
  55. float    random[VERTS];
  56.  
  57. int    np = 0;
  58. int    nv3 = 0;
  59. int    nv4 = 0;
  60.  
  61.  
  62. /* PROTOTYPES */
  63. unsigned long lcm_seed;
  64. void lcm_randomize(unsigned long);
  65. unsigned long lcm_rnd();
  66.  
  67. void init_vars();
  68. void gen_data();
  69. void write_to_hdf();
  70.  
  71.  
  72. /* MAIN */
  73. main(argc, argv)
  74.     int argc;
  75.     char * argv[];
  76. {
  77.     /* Initialize global variables */
  78.     init_vars();
  79.  
  80.     /* Generate the data for the file */
  81.     gen_data();
  82.  
  83.     /* Write the data to the file */
  84.     write_to_hdf();
  85. }
  86.  
  87.  
  88. /* FUNCTION DECLARATIONS */
  89.  
  90. void
  91. init_vars()
  92. /* DESCRIPTION:  Reinitializes all global variables to prepare for generating
  93. another set of data.
  94. */
  95. {
  96.     nv3 = 0;
  97.     nv4 = 0;
  98.     np = 0;
  99. }
  100.  
  101. void tetra(float, float, float, float);
  102. void rpp(float, float, float, float, float, float);
  103.  
  104. void
  105. gen_data()
  106. /* DESCRIPTION:  Generates data describing test world that we want to display.
  107. */
  108. {
  109.     float x, y, z;
  110.  
  111.     /* Create a field of tetrahedrons witha final row of rpps */
  112.     for (x = 0.0; x < 4.0; x += 1.0) {
  113.         for (z = 8.0; z >= 5.0; z -= 1.0) {
  114.             tetra(x, 0.0, z, 0.5);
  115.         }
  116.         rpp(x, 0.0, 4.0,  0.5, 0.5, 0.5);
  117.     }
  118.  
  119.     
  120.  
  121.     /* Create an aisle of rpps */
  122.     rpp(1.0, 0.0, 1.0,  0.5, 0.5, 2.5);
  123.     rpp(2.0, 0.0, 1.0,  0.5, 0.5, 2.5);
  124.  
  125.     /* Create an end for the aisle */
  126.     rpp(1.0, 0.0, 0.0,  1.5, 0.5, 0.5);
  127.  
  128.  
  129.     /* Create a final tunnel of cubes */
  130.     for (x = 3.0; x <= 14.0; x += 1.0) {
  131.         for (z = 0.0; z <= 1.0; z += 1.0) {
  132.             rpp(x, 0.0, z, 0.5, 0.5, 0.5);
  133.         }
  134.     }
  135.     
  136.     for (x = 2.5; x <= 14.5; x += 1.0) {
  137.         for (y = -0.5; y <= 0.5; y += 1.0) {
  138.             rpp(x, y, 0.5, 0.5, 0.5, 0.5);
  139.         }
  140.     }
  141.     
  142.  
  143. }
  144.  
  145.     int
  146.     add_pt(x, y, z)
  147.         float x, y, z;
  148.     /* DESCRIPTION:  Adds points x, y, and z to the px, py, and pz arrays,
  149.     respectively.  Also adds random number to the random array.  Increments 
  150.     np.
  151.     */
  152.     {
  153.         px[np] = x;
  154.         py[np] = y;
  155.         pz[np] = -z;
  156.  
  157.         random[np] = RND(0.0, 1.0);
  158.  
  159.         np++;
  160.  
  161.         return np-1;
  162.     }
  163.  
  164.  
  165.     void
  166.     connect3(p0, p1, p2)
  167.         int p0, p1, p2;
  168.     /* DESCRIPTION:  Connects points p0, p1, p2 in the plist3 and plist4
  169.     arrays.  Increments nv3 and nv4. */
  170.     {
  171.         plist3[nv3*3+0] = p0+1;
  172.         plist3[nv3*3+1] = p1+1;
  173.         plist3[nv3*3+2] = p2+1;
  174.  
  175.         plist4[nv4*4+0] = p0+1;
  176.         plist4[nv4*4+1] = p1+1;
  177.         plist4[nv4*4+2] = p2+1;
  178.         plist4[nv4*4+3] = 0;
  179.  
  180.         nv3++;
  181.         nv4++;
  182.     }
  183.  
  184.  
  185.     void
  186.     connect4(p0, p1, p2, p3)
  187.         int p0, p1, p2, p3;
  188.     /* DESCRIPTION:  Connects points p0, p1, p2, p3 in the plist4 array.
  189.     Increments nv4. */
  190.     {
  191.         plist4[nv4*4+0] = p0+1;
  192.         plist4[nv4*4+1] = p1+1;
  193.         plist4[nv4*4+2] = p2+1;
  194.         plist4[nv4*4+3] = p3+1;
  195.  
  196.         nv4++;
  197.     }
  198.  
  199.  
  200.     void
  201.     tetra(x, y, z, a)
  202.         float x, y, z, a;
  203.     /* DESCRIPTION:  Adds the vertices for a tetrahedron with corner (x,y,z)
  204.     and edge a to the px, py, and pz arrays, and connects them in plist3
  205.     and plist4.  The plist4 entry is padded with a zero for the fourth
  206.     entry.
  207.     */
  208.     {
  209.         int p0, p1, p2, p3;
  210.  
  211.         /* Add the four points to the array */
  212.         p0 = add_pt(x,y,z);
  213.         p1 = add_pt(x+a,y,z);
  214.         p2 = add_pt(x,y+a,z);
  215.         p3 = add_pt(x,y,z+a);
  216.  
  217.         /* Connect the dots */
  218.         connect3(p0, p2, p1);
  219.         connect3(p0, p3, p2);
  220.         connect3(p0, p1, p3);
  221.         connect3(p1, p2, p3);
  222.     }
  223.  
  224.  
  225.     void
  226.     rpp(x, y, z, a, b, c)
  227.         float x, y, z, a, b, c;
  228.     /* DESCRIPTION:  Adds the vertices for a rectangular parallelpiped 
  229.     with near corner (x, y, z) and far corner (x+a, y+b, z+c) to the
  230.     px, py, and pz arrays, and connects them in plist4.
  231.     */
  232.     {
  233.         int p[8];
  234.  
  235.         /* Add the points to the array */
  236.         p[0] = add_pt(x, y, z);
  237.         p[1] = add_pt(x, y+b, z);
  238.         p[2] = add_pt(x+a, y+b, z);
  239.         p[3] = add_pt(x+a, y, z);
  240.         p[4] = add_pt(x, y, z+c);
  241.         p[5] = add_pt(x, y+b, z+c);
  242.         p[6] = add_pt(x+a, y+b, z+c);
  243.         p[7] = add_pt(x+a, y, z+c);
  244.  
  245.         /* Connect the dots */
  246.         connect4(p[0], p[1], p[2], p[3]);
  247.         connect4(p[5], p[6], p[2], p[1]);
  248.         connect4(p[0], p[4], p[5], p[1]);
  249.         connect4(p[0], p[3], p[7], p[4]);
  250.         connect4(p[2], p[6], p[7], p[3]);
  251.         connect4(p[7], p[6], p[5], p[4]);
  252.     }
  253.  
  254.  
  255. void
  256. write_to_hdf()
  257. /* DESCRIPTION:  Writes the data sets to the a new hdf file.
  258. */
  259. {
  260.     DF        * f;
  261.  
  262.     VGROUP        * root;
  263.     VGROUP        * coil;
  264.     VGROUP        * prop;
  265.     VGROUP        * mobility;
  266.     VGROUP        * frame;
  267.  
  268.     VDATA        * vpx;
  269.     VDATA        * vpy;
  270.     VDATA        * vpz;
  271.     VDATA        * vplist3;
  272.     VDATA        * vplist4;
  273.     VDATA        * vtemp;
  274.  
  275.     int        vgid, vdataid;
  276.  
  277.     char        name[80];
  278.     int        n;
  279.  
  280.  
  281.  
  282.     /* Create the HDF file */
  283.     f = DFopen("demo.hdf", DFACC_ALL, 0);
  284.  
  285.  
  286.     /* Initialize Vgroup and Vdata ids for creating new items */
  287.     vgid = -1;
  288.     vdataid = -1;
  289.  
  290.  
  291.     /* Create the root's child vgroups */
  292.     coil = (VGROUP *) Vattach(f, -1, "w");
  293.     Vsetname(coil, "coil");
  294.     prop = (VGROUP *) Vattach(f, -1, "w");
  295.     Vsetname(prop, "prop");
  296.     mobility = (VGROUP *) Vattach(f, -1, "w");
  297.     Vsetname(mobility, "mobility");
  298.  
  299.     /* Create the root and insert its children */
  300.     root = (VGROUP *) Vattach(f, -1, "w");
  301.     Vsetname(root, "/");
  302.     Vinsert(root, coil);
  303.     Vinsert(root, prop);
  304.     Vinsert(root, mobility);
  305.     Vdetach(root);
  306.  
  307.  
  308.     /* Create the vdatas for the frames of the animation */
  309.     vpx = (VDATA *) VSattach(f, -1, "w");
  310.     VSsetname(vpx, "px");
  311.     VSsetfields(vpx, "px");
  312.     VSwrite(vpx, px, np, NO_INTERLACE);
  313.  
  314.     vpy = (VDATA *) VSattach(f, -1, "w");
  315.     VSsetname(vpy, "py");
  316.     VSsetfields(vpy, "py");
  317.     VSwrite(vpy, pz, np, NO_INTERLACE);
  318.  
  319.     vpz = (VDATA *) VSattach(f, -1, "w");
  320.     VSsetname(vpz, "pz");
  321.     VSsetfields(vpz, "pz");
  322.     VSwrite(vpz, py, np, NO_INTERLACE);
  323.  
  324.  
  325.     /* Create random scientific values dataset */
  326.     vtemp = (VDATA *) VSattach(f, -1, "w");
  327.     VSfdefine(vtemp, "temp", LOCAL_FLOATTYPE, 1);
  328.     VSsetname(vtemp, "temp");
  329.     VSsetfields(vtemp, "temp");
  330.     VSwrite(vtemp, random, np, NO_INTERLACE);
  331.  
  332.  
  333.     /* Create plist3 and plist4 vdatasets and insert them in group1 */
  334.     vplist3 = (VDATA *) VSattach(f, -1, "w");
  335.     VSfdefine(vplist3, "plist3", LOCAL_INTTYPE, 3);
  336.     VSsetname(vplist3, "plist3");
  337.     VSsetfields(vplist3, "plist3");
  338.     VSwrite(vplist3, plist3, nv3, NO_INTERLACE);
  339.  
  340.     vplist4 = (VDATA *) VSattach(f, -1, "w");
  341.     VSfdefine(vplist4, "plist4", LOCAL_INTTYPE, 4);
  342.     VSsetname(vplist4, "plist4");
  343.     VSsetfields(vplist4, "plist4");
  344.     VSwrite(vplist4, plist4, nv4, NO_INTERLACE);
  345.  
  346.  
  347.     /* Create 30 frames under the coil group.  Insert all of the */
  348.     /* data sets in there. */
  349.     for (n = 1; n <= 30; n++) {
  350.         sprintf(name, "frame%02d", n);
  351.         frame = (VGROUP *) Vattach(f, -1, "w");
  352.         Vsetname(frame, name);
  353.         Vinsert(coil, frame);
  354.  
  355.         /* Insert the vdatas under the current frame */
  356.         Vinsert(frame, vpx);
  357.         Vinsert(frame, vpy);
  358.         Vinsert(frame, vpz);
  359.         Vinsert(frame, vplist3);
  360.         Vinsert(frame, vplist4);
  361.         Vinsert(frame, vtemp);
  362.  
  363.         Vdetach(frame);
  364.     }
  365.  
  366.     VSdetach(vpx);
  367.     VSdetach(vpy);
  368.     VSdetach(vpz);
  369.     VSdetach(vplist3);
  370.     VSdetach(vplist4);
  371.     VSdetach(vtemp);
  372.  
  373.     /* Close down the main groups, now that we're done with them */
  374.     Vdetach(coil);
  375.     Vdetach(prop);
  376.     Vdetach(mobility);
  377.  
  378.     DFclose(f);
  379. }
  380.  
  381.  
  382. /* RANDOM NUMBER GENERATOR FUNCTIONS */
  383.  
  384. void lcm_randomize(seed)
  385.         unsigned long seed;
  386. {
  387.         lcm_seed = seed;
  388. }
  389.  
  390.  
  391. unsigned long lcm_rnd()
  392. {
  393.         unsigned long rnd_val;
  394.  
  395.         rnd_val = lcm_seed;
  396.         lcm_seed = ((314159269 * lcm_seed) + 453806245) % MAX_RND;
  397.         return (rnd_val);
  398. }
  399.